|
Modula-2 is a computer programming language designed and developed between 1977 and 1985 by Niklaus Wirth at the Swiss Federal Institute of Technology in Zurich (ETH Zurich) as a revision of Pascal to serve as the sole programming language for the operating system and application software for the personal workstation Lilith.〔(Summary of Projects by N. Wirth, 1962-1999 )〕 The principal concepts were: * The module as a compilation unit for separate compilation * The coroutine as the basic building block for concurrent processes * Types and procedures that allow access to machine-specific data. Modula-2 was viewed by Niklaus Wirth as a successor to his earlier programming languages Pascal and Modula.〔N. Wirth, Pascal and its Successors. In Software Pioneers, M. Broy and E. Denert, Eds. Springer-Verlag, 2002, ISBN 3-540-43081-4〕 The language design was also influenced by the Mesa language and the new programming possibilities of the early personal computer Xerox Alto, both from Xerox, that Wirth saw during his 1976 sabbatical year at Xerox PARC.〔N. Wirth, Programming in Modula-2, fourth Edition, page 4.〕 The computer magazine BYTE devoted the August 1984 issue to the language and its surrounding environment.〔BYTE – The Small Systems Journal, 1984 (8), pp. 143-232. (Available at archive.org )〕 == Description == Modula-2 is a general purpose procedural language, sufficiently flexible to do systems programming, but with much broader application. In particular, it was designed to support separate compilation and data abstraction in a straightforward way. Much of the syntax is based on Wirth's earlier and better-known language, Pascal. Modula-2 was designed to be broadly similar to Pascal, with some elements and syntactic ambiguities removed and the important addition of the ''module'' concept, and direct language support for multiprogramming. Here is an example of the source code for the "Hello world" program: MODULE Hello; FROM STextIO IMPORT WriteString; BEGIN WriteString("Hello World!"); END Hello. The Modula-2 ''module'' may be used to encapsulate a set of related subprograms and data structures, and restrict their visibility from other portions of the program. The module design implemented the data abstraction feature of Modula-2 in a very clean way. Modula-2 programs are composed of modules, each of which is made up of two parts: a definition module, the interface portion, which contains only those parts of the subsystem that are ''exported'' (visible to other modules), and an implementation module, which contains the working code that is internal to the module. The language has strict scope control. In particular the scope of a module can be considered as an impenetrable wall: Except for standard identifiers no object from the outer world is visible inside a module unless explicitly imported; no internal module object is visible from the outside unless explicitly exported. Suppose module M1 exports objects a, b, c, and P by enumerating its identifiers in an explicit export list DEFINITION MODULE M1; EXPORT QUALIFIED a, b, c, P; ... Then the objects a, b,c, and P from module M1 become now known outside module M1 as M1.a, M1.b, M1.c, and M1.P. They are exported in a ''qualified'' manner to the universe (assumed module M1 is global). The exporting module's name, i.e. M1, is used as a qualifier followed by the object's name. Suppose module M2 contains the following IMPORT declaration MODULE M2; IMPORT M1; ... Then this means that the objects exported by module M1 to the universe of its enclosing program can now be used inside module M2. They are referenced in a ''qualified'' manner like this: M1.a, M1.b, M1.c, and M1.P. Example: ... M1.a := 0; M1.c := M1.P(M1.a + M1.b); ... Qualified export avoids name clashes: For instance, if another module M3 would also export an object called P, then we can still distinguish the two objects, since M1.P differs from M3.P. Thanks to the qualified export it does not matter that both objects are called P inside their exporting modules M1 and M3. There is an alternative technique available, which is in wide use by Modula-2 programmers. Suppose module M4 is formulated as this MODULE M4; FROM M1 IMPORT a, b, c, P; Then this means that objects exported by module M1 to the universe can again be used inside module M4, but now by mere references to the exported identifiers in an "unqualified" manner like this: a, b, c, and P. Example: ... a := 0; c := P(a + b); ... This technique of unqualifying import allows use of variables and other objects outside their exporting module in exactly the same simple, i.e. ''unqualified'', manner as inside the exporting module. The walls surrounding all modules have now become irrelevant for all those objects for which this has been explicitly allowed. Of course unqualifying import is only usable if there are no name clashes. These export and import rules may seem unnecessarily restrictive and verbose. But they do not only safeguard objects against unwanted access, but also have the pleasant side-effect of providing automatic cross-referencing of the definition of every identifier in a program: if the identifier is qualified by a module name, then the definition comes from that module. Otherwise if it occurs unqualified, simply search backwards, and you will either encounter a declaration of that identifier, or its occurrence in an IMPORT statement which names the module it comes from. This property becomes very useful when trying to understand large programs containing many modules. The language provides for (limited) single-processor concurrency (monitors, coroutines and explicit transfer of control) and for hardware access (absolute addresses, bit manipulation, and interrupts). It uses name equivalence . 抄文引用元・出典: フリー百科事典『 ウィキペディア（Wikipedia）』 ■ウィキペディアで「Modula-2」の詳細全文を読む スポンサード リンク
|